home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 September / PCWorld_2008-09_cd.bin / v cisle / sadanastroju / lightning-0.8-tb-win.xpi / components / calItipProtocolHandler.js < prev    next >
Text File  |  2006-08-21  |  8KB  |  224 lines
  1. /* -*- Mode: javascript; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
  2. /* ***** BEGIN LICENSE BLOCK *****
  3.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public License Version
  6.  * 1.1 (the "License"); you may not use this file except in compliance with
  7.  * the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/MPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is Lightning code.
  16.  *
  17.  * The Initial Developer of the Original Code is Oracle Corporation
  18.  * Portions created by the Initial Developer are Copyright (C) 2005
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *   Mike Shaver <shaver@mozilla.org>
  23.  *
  24.  * Alternatively, the contents of this file may be used under the terms of
  25.  * either the GNU General Public License Version 2 or later (the "GPL"), or 
  26.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27.  * in which case the provisions of the GPL or the LGPL are applicable instead
  28.  * of those above. If you wish to allow use of your version of this file only
  29.  * under the terms of either the GPL or the LGPL, and not to allow others to
  30.  * use your version of this file under the terms of the MPL, indicate your
  31.  * decision by deleting the provisions above and replace them with the notice
  32.  * and other provisions required by the GPL or the LGPL. If you do not delete
  33.  * the provisions above, a recipient may use your version of this file under
  34.  * the terms of any one of the MPL, the GPL or the LGPL.
  35.  *
  36.  * ***** END LICENSE BLOCK ***** */
  37.  
  38. const CI = Components.interfaces;
  39.  
  40. const ITIP_HANDLER_MIMETYPE = "application/x-itip-internal";
  41. const ITIP_HANDLER_PROTOCOL = "moz-cal-handle-itip";
  42.  
  43. const CAL_ITIP_PROTO_HANDLER_CID =
  44.     Components.ID("{6E957006-B4CE-11D9-B053-001124736B74}");
  45. const CAL_ITIP_PROTO_HANDLER_CONTRACTID =
  46.     "@mozilla.org/network/protocol;1?name=" + ITIP_HANDLER_PROTOCOL;
  47.  
  48. const CALMGR_CONTRACTID = "@mozilla.org/calendar/manager;1";
  49.  
  50. const ItipProtocolHandlerFactory =
  51. {
  52.     createInstance: function (outer, iid) {
  53.         if (outer != null)
  54.             throw Components.results.NS_ERROR_NO_AGGREGATION;
  55.  
  56.         return (new ItipProtocolHandler()).QueryInterface(iid);
  57.     }
  58. };
  59.  
  60. const CAL_ITIP_CONTENT_HANDLER_CID =
  61.     Components.ID("{47C31F2B-B4DE-11D9-BFE6-001124736B74}");
  62. const CAL_ITIP_CONTENT_HANDLER_CONTRACTID =
  63.     "@mozilla.org/uriloader/content-handler;1?type=" +
  64.     ITIP_HANDLER_MIMETYPE;
  65.  
  66. const ItipContentHandlerFactory =
  67. {
  68.     createInstance: function (outer, iid) {
  69.         if (outer != null)
  70.             throw Components.results.NS_ERROR_NO_AGGREGATION;
  71.  
  72.         return (new ItipContentHandler()).QueryInterface(iid);
  73.     }
  74. };
  75.  
  76. function NYI()
  77. {
  78.     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  79. }
  80.  
  81. function ItipChannel(URI)
  82. {
  83.    this.URI = this.originalURI = URI;
  84. }
  85.  
  86. ItipChannel.prototype = {
  87.     QueryInterface: function (aIID) {
  88.         if (!aIID.equals(CI.nsISupports) &&
  89.             !aIID.equals(CI.nsIChannel) &&
  90.             !aIID.equals(CI.nsIRequest))
  91.             throw Components.results.NS_ERROR_NO_INTERFACE;
  92.         
  93.         return this;
  94.     },
  95.     
  96.     contentType: ITIP_HANDLER_MIMETYPE,
  97.     loadAttributes: null,
  98.     contentLength: 0,
  99.     owner: null,
  100.     loadGroup: null,
  101.     notificationCallbacks: null,
  102.     securityInfo: null,
  103.     
  104.     open: NYI,
  105.     asyncOpen: function (observer, ctxt) {
  106.         observer.onStartRequest(this, ctxt);
  107.     },
  108.     asyncRead: function (listener, ctxt) {
  109.         return listener.onStartRequest(this, ctxt);
  110.     },
  111.     
  112.     isPending: function () { return true; },
  113.     status: Components.results.NS_OK,
  114.     cancel: function (status) { this.status = status; },
  115.     suspend: NYI,
  116.     resume: NYI,
  117. };
  118.  
  119. function ItipProtocolHandler() { }
  120.  
  121. ItipProtocolHandler.prototype = {
  122.     QueryInterface: function (aIID) {
  123.         if (!aIID.equals(CI.nsISupports) &&
  124.             !aIID.equals(CI.nsIProtocolHandler))
  125.             throw Components.results.NS_ERROR_NO_INTERFACE;
  126.  
  127.         return this;
  128.     },
  129.     
  130.     protocolFlags: CI.nsIProtocolHandler.URI_NORELATIVE,
  131.     allowPort: function () { return false; },
  132.     isSecure: false,
  133.     newURI: function (spec, charSet, baseURI)
  134.     {
  135.         var cls = Components.classes["@mozilla.org/network/standard-url;1"];
  136.         var url = cls.createInstance(CI.nsIStandardURL);
  137.         url.init(CI.nsIStandardURL.URLTYPE_STANDARD, 0, spec, charSet, baseURI);
  138.         dump("Creating new URI for " + spec + "\n");
  139.         return url.QueryInterface(CI.nsIURI);
  140.     },
  141.     
  142.     newChannel: function (URI) {
  143.         dump("Creating new ItipChannel for " + URI + "\n");
  144.         return new ItipChannel(URI);
  145.     },
  146. };
  147.  
  148. function ItipContentHandler() { }
  149.  
  150. ItipContentHandler.prototype = {
  151.     QueryInterface: function (aIID) {
  152.         if (!aIID.equals(CI.nsISupports) &&
  153.             !aIID.equals(CI.nsIContentHandler))
  154.             throw Components.results.NS_ERROR_NO_INTERFACE;
  155.         
  156.         return this;
  157.     },
  158.  
  159.     handleContent: function (contentType, windowTarget, request)
  160.     {
  161.         dump("Handling some itip content, whee\n");
  162.         var channel = request.QueryInterface(CI.nsIChannel);
  163.         var uri = channel.URI.spec;
  164.         if (uri.indexOf(ITIP_HANDLER_PROTOCOL + ":") != 0) {
  165.             dump("unexpected uri " + uri + "\n");
  166.             return Components.results.NS_ERROR_FAILURE;
  167.         }
  168.         // moz-cal-handle-itip:///?
  169.         var paramString = uri.substring(ITIP_HANDLER_PROTOCOL.length + 4);
  170.         var paramArray = paramString.split("&");
  171.         var paramBlock = { };
  172.         paramArray.forEach(function (v) {
  173.             var parts = v.split("=");
  174.             paramBlock[parts[0]] = unescape(unescape(parts[1]));
  175.             });
  176.         // dump("content-handler: have params " + paramBlock.toSource() + "\n");
  177.         var event = Components.classes["@mozilla.org/calendar/event;1"].
  178.             createInstance(CI.calIEvent);
  179.         event.icalString = paramBlock.data;
  180.         dump("Processing iTIP event '" + event.title + "' from " +
  181.             event.organizer.id + " (" + event.id + ")\n");
  182.         var calMgr = Components.classes[CALMGR_CONTRACTID].getService(CI.calICalendarManager);
  183.         var cals = calMgr.getCalendars({});
  184.         cals[0].addItem(event, null);
  185.     }
  186. };
  187.  
  188. var myModule = {
  189.     registerSelf: function (compMgr, fileSpec, location, type) {
  190.         debug("*** Registering Lightning " + ITIP_HANDLER_PROTOCOL + ": handler\n");
  191.         compMgr = compMgr.QueryInterface(CI.nsIComponentRegistrar);
  192.         compMgr.registerFactoryLocation(CAL_ITIP_PROTO_HANDLER_CID,
  193.                                         "Lightning " + ITIP_HANDLER_PROTOCOL + ": handler",
  194.                                         CAL_ITIP_PROTO_HANDLER_CONTRACTID,
  195.                                         fileSpec, location, type);
  196.         debug("*** Registering Lightning " + ITIP_HANDLER_MIMETYPE + " handler\n");
  197.         compMgr.registerFactoryLocation(CAL_ITIP_CONTENT_HANDLER_CID,
  198.                                         "Lightning " + ITIP_HANDLER_MIMETYPE + " handler",
  199.                                         CAL_ITIP_CONTENT_HANDLER_CONTRACTID,
  200.                                         fileSpec, location, type);
  201.     },
  202.  
  203.     getClassObject: function (compMgr, cid, iid) {
  204.         if (!iid.equals(Components.interfaces.nsIFactory))
  205.             throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  206.  
  207.         if (cid.equals(CAL_ITIP_PROTO_HANDLER_CID))
  208.             return ItipProtocolHandlerFactory;
  209.  
  210.         if (cid.equals(CAL_ITIP_CONTENT_HANDLER_CID))
  211.             return ItipContentHandlerFactory;
  212.  
  213.        throw Components.results.NS_ERROR_NO_INTERFACE;
  214.     },
  215.  
  216.     canUnload: function(compMgr) {
  217.         return true;
  218.     }
  219. };
  220.  
  221. function NSGetModule(compMgr, fileSpec) {
  222.     return myModule;
  223. }
  224.